const mysql = require('mysql2');//  mysql版本为8.x
const dbconfig = require('./database');

// 使用连接池
const pool = mysql.createPool({
  ...dbconfig.mysql,
  // mysql2 特有配置
  waitForConnections: true,
  connectionLimit: 10,
  queueLimit: 0,
//   acquireTimeout: 10000, // 无效的参数
//   timeout: 60000// 无效的参数
});

// module 模块系统
// 把db对象挂在了模块系统对象上
module.exports = {
  /**
   * 执行 SQL 查询（支持参数化查询）
   * @param {string} sql - SQL 语句，可使用 ? 作为占位符
   * @param {Array} params - 参数数组，对应 SQL 中的 ? 占位符
   * @returns {Promise} 返回查询结果的 Promise
   */
  query: function (sql, params = []) {
    return new Promise((resolve, reject) => {
      pool.getConnection(function (err, connection) {
        if (err) {
          console.error('数据库连接失败:', err);
          reject(err);
          return;
        }

        // mysql2 的 query 方法参数顺序不同
        connection.query(sql, params, function (err, rows, fields) {
          // 释放连接回连接池
          connection.release();
          
          if (err) {
            console.error('SQL 执行失败:', err);
            console.error('SQL:', sql);
            console.error('参数:', params);
            reject(err);
          } else {
            // console.log("连接数据库成功~~");
            resolve(rows);
          }
        });
      });
    });
  },

  /**
   * 执行事务（mysql2 版本）
   * @param {Function} transactionFn - 事务函数，接收 connection 参数
   * @returns {Promise} 返回事务执行结果的 Promise
   */
  transaction: function (transactionFn) {
    return new Promise((resolve, reject) => {
      pool.getConnection(function (err, connection) {
        if (err) {
          reject(err);
          return;
        }

        // mysql2 开始事务
        connection.beginTransaction(function (err) {
          if (err) {
            connection.release();
            reject(err);
            return;
          }

          // 执行事务操作
          Promise.resolve(transactionFn(connection))
            .then(result => {
              // 提交事务
              connection.commit(function (err) {
                if (err) {
                  return connection.rollback(function () {
                    connection.release();
                    reject(err);
                  });
                }
                connection.release();
                resolve(result);
              });
            })
            .catch(error => {
              // 回滚事务
              connection.rollback(function () {
                connection.release();
                reject(error);
              });
            });
        });
      });
    });
  },

  /**
   * 使用 Promise API（mysql2 推荐方式）
   */
  promise: {
    /**
     * 执行 SQL 查询（Promise API）
     */
    query: function (sql, params = []) {
      return pool.promise().query(sql, params)
        .then(([rows, fields]) => rows)
        .catch(err => {
          console.error('SQL 执行失败:', err);
          console.error('SQL:', sql);
          console.error('参数:', params);
          throw err;
        });
    },

    /**
     * 执行事务（Promise API）
     */
    transaction: async function (transactionFn) {
      const connection = await pool.promise().getConnection();
      
      try {
        await connection.beginTransaction();
        const result = await transactionFn(connection);
        await connection.commit();
        return result;
      } catch (error) {
        await connection.rollback();
        throw error;
      } finally {
        connection.release();
      }
    }
  },

  /**
   * 关闭连接池
   */
  close: function () {
    return new Promise((resolve, reject) => {
      pool.end(function (err) {
        if (err) {
          reject(err);
        } else {
          console.log('数据库连接池已关闭');
          resolve();
        }
      });
    });
  }
};